﻿/////////////////////////////////////////////////////////////////////////////////
///              ESCUELA SUPERIOR POLITECNICA DE CHIMBORAZO                   ///
///                        PROYECTO INTEGRADOR III                            /// 
///                         PROYECTO ACOSIS 2009                              /// 
/// ------------------------------------------------------------------------- ///  
///              **********GRUPO DE DESARROLLADORES**********                 ///
///                 ************ESTRELLA ROJA*************                    /// 
///---------------------------------------------------------------------------///
///                                                         RIOBAMBA-ECUADOR  ///
///---------------------------------------------------------------------------///
///                          COMPONENTE DE CLASES                             ///
/////////////////////////////////////////////////////////////////////////////////


using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Linq;
using System.Text;

namespace Negocios
{
    public partial class ComponeteNegocios : Component
    {
        private ClasesDeAcceso.clsAdministracion auxCls = new ClasesDeAcceso.clsAdministracion();
        private LogisticaDeAcceso.ClasesDeAcceso.clsAsignacionBienes auxClsAsigBienes = new LogisticaDeAcceso.ClasesDeAcceso.clsAsignacionBienes();
        private LogisticaDeAcceso.ClasesDeAcceso.clsAsignacionServicios auxClsActivServ = new LogisticaDeAcceso.ClasesDeAcceso.clsAsignacionServicios();
        private LogisticaDeAcceso.ClasesDeAcceso.clsPedido auxClsPedido = new LogisticaDeAcceso.ClasesDeAcceso.clsPedido();
        private LogisticaDeAcceso.ClasesDeAcceso.clsCentroCostos auxClsCentro = new LogisticaDeAcceso.ClasesDeAcceso.clsCentroCostos();
        private LogisticaDeAcceso.ClasesDeAcceso.clsDepartamento auxClsDepartamento = new LogisticaDeAcceso.ClasesDeAcceso.clsDepartamento();
        private LogisticaDeAcceso.ClasesDeAcceso.clsProveedor auxClsProveedor = new LogisticaDeAcceso.ClasesDeAcceso.clsProveedor();
        private LogisticaDeAcceso.ClasesDeAcceso.clsRegistroProducto auxClsRegistroProducto = new LogisticaDeAcceso.ClasesDeAcceso.clsRegistroProducto();
        private LogisticaDeAcceso.ClasesDeAcceso.clsRegistroServicios auxClsRegistroServicio = new LogisticaDeAcceso.ClasesDeAcceso.clsRegistroServicios();
        private LogisticaDeAcceso.ClasesDeAcceso.clsProducto auxClsProducto = new LogisticaDeAcceso.ClasesDeAcceso.clsProducto();
        private LogisticaDeAcceso.ClasesDeAcceso.clsServicios auxClsServicios = new LogisticaDeAcceso.ClasesDeAcceso.clsServicios();


        public ComponeteNegocios()
        {
            InitializeComponent();
        }

        public ComponeteNegocios(IContainer container)
        {
            container.Add(this);

            InitializeComponent();
        }
         //DIVICION DE LOS ESQUEMAS DE LLAMADO POR MEDIO DEL ACCESO A LA BASE DE DATOS, CADA UNO DE LOS LLAMADOS ES DIRIGIDO PRO TABLAS INDEPENDIENTES

        /// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// ///////////////////////////SERVICIOS///////////////////////////////////////////////////////////////////////////


        //Ingreso de un nuevo servicio
        public void metIngresarServicio(string Con,string Codigo,string Deta,string Obse,string Des)
        {
            auxClsServicios.metConfiguracionIngresarServ(Con);
            auxClsServicios.metActivarIngresarServ(Codigo, Deta, Obse, Des);
    
        }
        //Conteo de filas en la tabla para asignacion de codigos
        public int metConteoMostrarServicios(string Con, LogisticaDeAcceso.ColeccionDeDatos Col)
        {
            auxClsServicios.metConfiguracionMostrarSer(Con);//Configuracion para mostrar los departamentos
            auxClsServicios.metActivarMostrarSer(Col);//Activa los metodos configurados anteriormente
            return auxClsServicios.metNumeroFilasDE(Col);
        } 
        //Eliminar serviccios registrados
        public void metEliminarRegServicio(string varConexion,string Codigo)
        {
            auxClsServicios.metConfigurarEliminarServicio(varConexion);
            auxClsServicios.metActivarEliminarServicio(Codigo);
        }
        //Actualiza la vista para mostrar los servicios
        public void metActualizarServiciosMod(string varConexion,string Cod,string Deta,string Obse,string Des)
        {
            auxClsServicios.metConfigurarActualizarServicios(varConexion);
            auxClsServicios.metActivarActualizarServicios(Cod, Deta, Obse, Des);
        }
        //Modalidades registradas
        public void metMostrarServiciosRegistradosMod(string Con,LogisticaDeAcceso.ColeccionDeDatos Col)
        {
            auxClsServicios.metConfigurarVistaServicios(Con);
            auxClsServicios.metActivarVistaServicios(Col);
        }
        //Inicio de la aplicacion
        public void metActualizarServiciosIngresoPrin(string Con, LogisticaDeAcceso.ColeccionDeDatos Col)
        {
            auxClsServicios.metConfiguracionMostrarSer(Con);//Llamado a la configuracion de la vista para mostrar los servicios registrados
            auxClsServicios.metActivarMostrarSer(Col);//Ativacion de los datos en el data set
        }
   
    
         /// ////////////////////////////////////////////////////////////////////////////////////////////////////////
         ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
         /// /////////////////////////////////////////////REGISTRO DE SERVICIOS  


        //Ingreso de un registro de servicio
        public void metIngresarRegServicio(string varConexion, string CodigoRP, string CodigoPR, string NumeroPed, string Observacion)
        {
            auxClsRegistroServicio.metConfiguracionIngresaRegSer(varConexion);
            auxClsRegistroServicio.metActivarIngresarRegSer(CodigoRP, CodigoPR, NumeroPed, Observacion, "Pendiente");
        }

        //Conteo de filas pàra asignacion de clave principal
        public int metRegistrosFilasIngresoPrin(string Con,LogisticaDeAcceso.ColeccionDeDatos Col)
        {
            auxClsRegistroServicio.metConfiguraMostrarRegistroSer(Con);//Configuracion para mostrar los departamentos
            auxClsRegistroServicio.metActivarMostrarRegistroSer(Col);//Activa los metodos configurados anteriormente
            return auxClsRegistroServicio.metNumeroFilasDE(Col);
        }
        //Cambiar el estado del registro
        public void metActualizarEstadoAsignarS(string varConexion, string Codigo)
        {
            auxClsRegistroServicio.metActualizarEstadoSer(varConexion);//Configura el procedimiento que devuelve el estado 
            auxClsRegistroServicio.metActivarActualizarEstadoServ(Codigo);////Activa el estado enviando el codigo actual como parametro
        }
      
        /// ////////////////////////////////////////////////////////////////////////////////////////////////////////////
       /////////////////////////////////////////////PRODUCTOS/////////////////////////////////////////////////////////

        //Eliminacion de un producto registrado
        public void metEliminarProductoMod(string varConexion, string Codigo)
        {
            auxClsProducto.metConfigurarEliminarProducto(varConexion);/////Configurcion del procedimiento almacenado
            auxClsProducto.metActivarEliminarProducto(Codigo);//Activacion del procedimiento almacenado
        }
        //Modificacion de un producto ya registrado
        public void metActualizarProducto(string varConexion, string Cod, string Deta, string NueTip)
        {
            auxClsProducto.metActualizarProducto(varConexion);/////////////////////////////////////////////////////////////Llamdo a la configuracion
            auxClsProducto.metActivarActualizarProducto(Cod, Deta, NueTip);/////Llamdo a la ctivacion del formulario
        }
        //Presentar los registros de bienes
        public void metMostrarBienesRegistradosMod(string varConexion, LogisticaDeAcceso.ColeccionDeDatos Col)
        {
            //Actualizar los datos ingresados para su operacion
            auxClsProducto.metConfiguracionMostarBienes(varConexion);////////Llamado a la configuracion del procedimiento
            auxClsProducto.metActivarMostrarBienes(Col);//Llamdo al ejecucion del procedimiento
        }
        //Presenta bienes registrados por grupos
        public void metActualizarProductoIngresoPrin(string varConexion, string Grupo, LogisticaDeAcceso.ColeccionDeDatos Col)
        {
            //Control de los detalles del producto con la descripcion de los grupos detallados
            //en el ombobox de grupo
            auxClsProducto.metConfigurarDatosPorGru(varConexion);
            auxClsProducto.metActivaDatosPorGrupo(Grupo, Col);
        } 
        //Registro en la base del bien
        public void metRegistrarBien(string varConexion,string Cod,string Det,string Gru,string Tip)
        {
            auxClsProducto.metConfigurarIngresoPR(varConexion);
            auxClsProducto.metActivarIngresoPR(Cod, Det, Gru, Tip);
        }
        //Conteo de bienes para asignacion de clave principal
        public int metContarBienes(string varConexion,string Grupo)
        {
            auxClsProducto.metConfigurarContarPR(varConexion);//metodo de configuracion de Conteo
            return auxClsProducto.metActivarContarPR(Grupo);//Metodo para Activar el conteo
        }
        //Comprobacion de la clave para la generacion de una nueva
        public string metExisteClaveBienes(string varConexion,string varCod)
        {
            auxClsProducto.metConfigurarGetExisteClave(varConexion);//configuracion del procedimiento almacenado getExisteclave
            return auxClsProducto.metActivarGetexisteClave(varCod);//activa el procedimiento almacenado
        }


        /// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /////////////////////////////////////////PROVEEDORES///////////////////////////////////////////////////////////////////

        //Mostrar proveedores registrados y contralos
        public int metCofigurarIngresoProveedores(string varConexion, LogisticaDeAcceso.ColeccionDeDatos Col)
        {
            auxClsProveedor.metConfigurarProveedoresRe(varConexion);//Configuracion para mostrar los departamentos
            auxClsProveedor.metActivarProveedoresReg(Col);//Activa los metodos configurados anteriormente
            return auxClsProveedor.metNumeroFilasDE(Col);
        }
        //Ingreso de un nuevo proveedor
        public void metIngresoNuevoProveedor(string Con, string Cod, string Nom, string Res, string Obser, string Ced, string Dir, string Tele, string Ciu, string Pais)
        {
            auxClsProveedor.metConfiguracionIngresarPr(Con);
            auxClsProveedor.metActivarIngreasPr(Cod, Nom, Res, Obser, Ced, Dir, Tele, Ciu, Pais);
        }
        //Presentar datos de los ultimos registros
        public void metActualizarDatosPro(string Com, LogisticaDeAcceso.ColeccionDeDatos Col)
        {
            auxClsProveedor.metConfigurarGetCiud(Com);
            auxClsProveedor.metActivarGetCiu(Col);
            auxClsProveedor.metConfigurarGetPai(Com);
            auxClsProveedor.metActivarGetPai(Col);
        }
        //Eliminacion de proveedores
        public void metEliminarProveedores(string varConexion, string Codigo)
        {
            auxClsProveedor.metConfiguracionEliminarProv(varConexion);
            auxClsProveedor.metActivarEliminarProv(Codigo);
        }
        //Modificacion de proveedores
        public void metActualizarProveedor(string Con, string Cod, string Nom, string Res, string Obs, string Ced, string Dir, string Tele, string Ciu, string Pais)
        {
            auxClsProveedor.metConfigurarActualizarProv(Con);
            auxClsProveedor.metActivarActualizarProv(Cod, Nom, Res, Obs, Ced, Dir, Tele, Ciu, Pais);
        }
        //Presentar proveedores registrados
        public void metMostrarProveedores(string Con, LogisticaDeAcceso.ColeccionDeDatos Col)
        {
            auxClsProveedor.metConfiguracionMostrarProveedor(Con);////////Configuracion del procedimiento almacenado
            auxClsProveedor.metActivarMostrarProveedor(Col);///Activacion del procedimiento
        }
        //Actualizar presentacion de los proveedores asignados
        public void metActualizarProveedoresAsignarS(string varConexion,LogisticaDeAcceso.ColeccionDeDatos Col)
        {
            auxClsProveedor.metConfigurarProveedoresRe(varConexion);//Configuracion para el acceso a la vista de proveedores registrados
            auxClsProveedor.metActivarProveedoresReg(Col);//activacion de la vista proveedores registrados
        }
        //Presentar datos de proveedores
        public void metActualizarProveedor(string varConexion, LogisticaDeAcceso.ColeccionDeDatos Col)
        {
            auxClsProveedor.metConfigurarProveedoresRe(varConexion);//Configuracion para el acceso a la vista de proveedores registrados
            auxClsProveedor.metActivarProveedoresReg(Col);//activacion de la vista proveedores registrados
        }


        /// //////////////////////////////////////////////////////////////////////////////////////////////
        /// /////////////////////////////////////////////////////////////////////////////////////////////Ç
        /// /////////////////////////////////////REGISTROS DE BIENES/////////////////////////////////////


        //Ingreso de un nuevo registro de bien
        public void metIngresarRegistroProducto(string varConexion, string Codigo, string Producto, int NumeroPedi, int CantidaPro, string UnidadMedi, string Observaciones)
        {
            auxClsRegistroProducto.metConfigurarIngreso(varConexion);///Variables de control de pedidos y de servicios d ingresos
            auxClsRegistroProducto.metActivarIngreso(Codigo, Producto, NumeroPedi, CantidaPro, UnidadMedi, Observaciones, "No asignado");
        }
        //Conteo y presentacion de bienes registrados
        public int metMostrarRegistrosIngresoPro(string Con, LogisticaDeAcceso.ColeccionDeDatos Col)
        {
            auxClsRegistroProducto.metConfigurarMostrarRegistros(Con);//Configuracion para mostrar los departamentos;
            auxClsRegistroProducto.metActivarMostarRegis(Col);
            return auxClsRegistroProducto.metNumeroFilasDE(Col);
        }
        //Cambiar estado del Bien
        public void metCambiarEstadoProducto(string Con,string Codigo)
        {
            auxClsRegistroProducto.metActualizarEstado(Con);
            auxClsRegistroProducto.metActivarActualizarEstado(Codigo);
        }
        //Presentar estado del registro
        public string metMostrarEstadosAA(string Con,string Cod)
        {
            auxClsRegistroProducto.metMostrarEstados(Con);
            return auxClsRegistroProducto.metActivarMostrarEstados(Cod);
        }
        // ///////////////////////////////////////////////////////////////////////////////////////////////////////////
         //////////////////////////////////////PEDIDOS////////////////////////////////////////////////////////////////

        //Eliminar pedido
        public void metEliminarPedidoIngresPrin(string varConexion, int Num)
        {
            auxClsPedido.metConfigurarEliminar(varConexion);
            auxClsPedido.metActivarEliminra(Num);
        }
        //Modificar de pedidos
        public void metActualizarPedidoIngresoPrin(string con, string NumeroPed, string Cust, string Soli, string Auto, string Moda, string NueEst, string Obser)
        {
            auxClsPedido.metConfigurarActualizarPE(con); //Configuracion del procedimiento de ingreso del pedido
            auxClsPedido.metActivarActualizarPE(NumeroPed, Cust, Soli, Auto, DateTime.Now.ToString(), Moda, NueEst, Obser);
        }
        //Modificar datos de ingreso principal
        public void metActualizarDatosACPedidoIngresoPrin(string Con, LogisticaDeAcceso.ColeccionDeDatos Col)
        {
            auxClsPedido.metConfigurarMostrarPedido(Con);
            auxClsPedido.metActivarMostrarPedido(Col);
        }
        //Ingresar nuevo pedido
        public int metIngresoPedido(string varConexion, string Codigo, string Cust, string Soli, string Auto, string Mod)
        {
            auxClsPedido.metConfiguracionNumeroP(varConexion);//Configura la vista para ver el numero que le toca en la asignacion del pedido
            int num = auxClsPedido.metActivarNumeroP();//activa la vista y devuelve el numero 
            auxClsPedido.metConfigurarIngreso(varConexion); //Configuracion del procedimiento de ingreso del pedido
            auxClsPedido.metActivarIngreso(num, Codigo, Cust, Soli, Auto, DateTime.Now.ToString(), Mod, "Activo", "Creacion del registro sin novedades");
            return num;
        }
        //Metodo Para modificar los datos de la unidad
        public void metActualizarDepPed(string Con,string Numer,string Cod)
        {
            auxClsPedido.metConfigurarActualizarPedDepa(Con);//Ingreso de la direccion
            auxClsPedido.metActivarActualizarPedDepa(Numer, Cod);
        }
        //Metodo para actualizar los estados de los datos ingresados en la tabla pedido
        public void metActualizarDatosACPedido(string varConexion, LogisticaDeAcceso.ColeccionDeDatos Col)
        {
            auxClsPedido.metConfigurarMostrarPedido(varConexion);
            auxClsPedido.metActivarMostrarPedido(Col);
        }
        //Datos para ingreso rapido
        public void metInicioPedidoIngresoPrin(string varConexion, LogisticaDeAcceso.ColeccionDeDatos Col)
        {
            auxClsPedido.metConfiguracionMostrarAuto(varConexion);//Para ver los datos ingresados en la columna autorizante
            auxClsPedido.metActivarMosAuto(Col);
            auxClsPedido.metConfiguracionMostrarCus(varConexion);//Para ver los datos ingresados en la columna Custodio
            auxClsPedido.metActivarMosCus(Col);
            auxClsPedido.metConfiguracionMostrarSol(varConexion);//Para ver los datos ingresados en la columna Solicitante
            auxClsPedido.metActivarMosSol(Col);
        }

     

        /// ///////////////////////////////////////////////////////////////////////////////////////////////
        /// //////////////////////////////////////////////////////////////////////////////////////////////
        /// ///////////////////////////CENTROS DE COSTOS
       

        //Eliminar centro de costos
        public void metEliminarCentroCostos(string varConexion, string Codigo)
        {
            auxClsCentro.metConfigurarEliminarCentro(varConexion);//////////Llamado a la modificacion
            auxClsCentro.metActivarEliminarCentro(Codigo);//Llamado al procedimiento almacenado
        }
        //Modificar centros de costos
        public void metActualizarCentrosCostos(string varConexion, string Codigo, string Nombre, string Respon, string Ubi)
        {
            auxClsCentro.metActualizarCentCostos(varConexion);
            auxClsCentro.metActivarActualizarCentroCostos(Codigo, Nombre, Respon, Ubi);
        }
        //Presentar centro de costos
        public void metMostrarCentrosCostosMod(string varConexion, LogisticaDeAcceso.ColeccionDeDatos Col)
        {
            //Metodo de inicio de datos registrados en la tabla de centro de costos
            auxClsCentro.metConfiguracionMostrar(varConexion);
            auxClsCentro.metActivarConMostra(Col);
        }
        //Presentar los centros de costos registrados
        public void metInicioCentroCostos(string varConexion,LogisticaDeAcceso.ColeccionDeDatos Col)
        {
            //inicializacion de alguno de los casilleros del ingreso de pedido
            // entre lgunos de ellos se encuentran los del autorizante, solicitante y custodio
            auxClsCentro.metConfiguracionMostrar(varConexion);//Configuracion de la vista que se encuentra registrada en la base de datos
            auxClsCentro.metActivarConMostra(Col);
        }
        //Presentar Centros de costos modificados 
        public void metActualizarCentroCostos(string varConexion, LogisticaDeAcceso.ColeccionDeDatos Col)
        {
            auxClsCentro.metConfiguracionMostrar(varConexion);//Configura el llamado a la vista de mostrar datos del centro de costos
            auxClsCentro.metActivarConMostra(Col);//Activa la vista
        }
        //Conteo de filas y presentar los datos del registro
        public int metContarFilasCentroCostos(string varConexion, LogisticaDeAcceso.ColeccionDeDatos Col)
        {
            auxClsCentro.metConfigurarNumeroFilas(varConexion);//Configuracion para mostrar los departamentos
            auxClsCentro.metActivarNumeroFila(Col);
            return auxClsCentro.setNumeroFilas(Col);
        }
        //Llamado al procedimiento de ingreso de centro de costos
        public void metIngresarCentroCostos(string varConexion, string CodCen, string Nombre, string Res, string Ubi)
        {
            auxClsCentro.metConfigurarIngreso(varConexion);//Configuracion del procedimiento
            auxClsCentro.metActivarIngreso(CodCen, Nombre, Res, Ubi);
            //Activacion del procedimiento
        }
        //Inicio
        public void metInicioCentroCostosIngresoPrin(string varConexion, LogisticaDeAcceso.ColeccionDeDatos Col)
        {
            //inicializacion de alguno de los casilleros del ingreso de pedido
            // entre lgunos de ellos se encuentran los del autorizante, solicitante y custodio
            auxClsCentro.metConfiguracionMostrar(varConexion);//Configuracion de la vista que se encuentra registrada en la base de datos
            auxClsCentro.metActivarConMostra(Col);
        }

        // /////////////////////////////////////////////////////////////////////////////////////////////
        /// ///////////////////////////////////////////////////////////////////////////////////////////
        /// /////////////////////UNIDADES ADQUISITIVAS/////////////////////////////////////////////////

        
        public void metActualizarUnidadesIngresoPrin(string varConexion, string Centro, LogisticaDeAcceso.ColeccionDeDatos Col)
        {
            ///////////////////////////////////////////////////Metodo actualiza el dataset(colecciondedatos1) para ver los nuevos cambios que se produscan en la tabla
            ///////////////////////////////////////////////////tDepartamento
            auxClsDepartamento.metConfiPresentarDepartamentos(varConexion);//configuracion del procedimiento que devuelve una tabla
            auxClsDepartamento.metActivarPresentarDep(Centro, Col);//Activacion del procedimiento
        }

        public void metActualizarUnidades(string varConexion,string Centro,LogisticaDeAcceso.ColeccionDeDatos Col)
        {
            //este metodo actualiza el dataset(colecciondedatos1) para ver los nuevos cambios que se produscan en la tabla
            //tDepartamento
            auxClsDepartamento.metConfiPresentarDepartamentos(varConexion);//configuracion del procedimiento que devuelve una tabla
            auxClsDepartamento.metActivarPresentarDep(Centro, Col);//Activacion del procedimiento
        }
        //Modificacion de una unidad registrada
        public void metModificarUnidad(string varConexion, string Nombre, LogisticaDeAcceso.ColeccionDeDatos Col)
        {
            auxClsDepartamento.metConfiguracionMostraDatModificar(varConexion);
            auxClsDepartamento.metActivarMostrarDatModificar(Nombre, Col);
        }
        //Eliminacion de una unidad
        public void metEliminarDepartamento(string Con, string Codigo)
        {
            auxClsDepartamento.metConfigurarEliminarDepa(Con);
            auxClsDepartamento.metActivarEliminarDepa(Codigo);
        }
        //Presentar unidades registradas unicas
        public void metMostrarCentrosUnicos(string Con, LogisticaDeAcceso.ColeccionDeDatos Col)
        {
            auxClsDepartamento.metMostrarCentroUnicos(Con);
            auxClsDepartamento.metActivarMostrarCentroUnicos(Col);
        }
        //Modificar datos unidades
        public void metActualizarDepartamento(string varConexion, string Codigo, string Nombre, string Repre, string Tele, string Ubi)
        {
            auxClsDepartamento.metModificarDepartamento(varConexion);
            auxClsDepartamento.metActivarModificarDepartamento(Codigo, Nombre, Repre, Tele, Ubi);
        }

        public void metIniciarSesionDEPA(string varConexion, LogisticaDeAcceso.ColeccionDeDatos Col)
        {
            auxClsDepartamento.metConfiguarMostraDe(varConexion);//Metodo que muestra los departamentos registrados
            auxClsDepartamento.metActivaMostrarDE(Col);//Activa el metodo anterior
        }

        public int metContarFilasDepartamento(string varConexion, LogisticaDeAcceso.ColeccionDeDatos Col)
        {
            auxClsDepartamento.metConfiguarMostraDe(varConexion);//Configuracion para mostrar los departamentos
            auxClsDepartamento.metActivaMostrarDE(Col);//Activa los metodos configurados anteriormente
            return auxClsDepartamento.metNumeroFilasDE(Col);
        }

        public void metIngresoDepartamento(string varConexion, string Cod, string CodCen, string Nombre, string Rep, string Tele, string Ubi)
        {
            //Metodo que ingresa el nuevo registro del departamento
            auxClsDepartamento.metConfiguracionInsertar(varConexion);//Configuracion del procedimiento          
            auxClsDepartamento.metActivarInsertar(Cod, CodCen, Nombre, Rep, Tele, Ubi);//Activacion
            //del procedimiento de ingreso
        }



        /// //////////////////////////////////////////////////////////////////////////////////////////
        /// //////////////ASIGANCION DE BIENES///////////////////////////////////////////////////////

        //Modificacion de los bienes asignados
        public void metActualizarRegistrosBienes(string Con, int num, string Cod)
        {
            auxClsAsigBienes.metConfigurarActualizar(Con);
            auxClsAsigBienes.metActivarActualizar(num, Cod);
        }
        //Modificacion de asignaciones registradas
        public void metActualizarPedidos(string varConexion, LogisticaDeAcceso.ColeccionDeDatos Col)
        {
            auxClsAsigBienes.metConfigurarMostrarPedido(varConexion);
            auxClsAsigBienes.metActivarMostarPedido(Col);
        }
        //Cambiar el estado de la asignacion
        public void metActualizarDatos(string Con,int num,string Pal)
        {
            auxClsAsigBienes.metConfigurarActualizar(Con);
            auxClsAsigBienes.metActivarActualizar(num, Pal);
        }
        //Inicio de las presentaciones
        public void metInicio(string Con,LogisticaDeAcceso.ColeccionDeDatos Col)
        {
            auxClsAsigBienes.metConfigurarRegistrosInactivos(Con);
            auxClsAsigBienes.metActivarRegistrosInactivos(Col);
        }

        //Ingreso de datos extras para el registro de la asignacion
        public void metIngresarDatos(string varConexion, string cod, string cod2, string Com, string fecha, string Mod, string Obs, string FechaA)
        {
            auxClsAsigBienes.metConfigurarIngresarAsignacionB(varConexion);
            auxClsAsigBienes.metActivarIngresarAsignacionB(cod, cod2, Com, fecha, Mod, Obs, "Pendiente", FechaA);
        }
        //Presentar bienes
        public void metMostrarBienesAA(string varConexion, LogisticaDeAcceso.ColeccionDeDatos Col, string numero)
        {
            auxClsAsigBienes.metConfigurarMostrarBienes(varConexion);//Configura la actualizacion
            auxClsAsigBienes.metActivarMostrarBienes(Col, numero);//Activa la vista
        }
        //Eliminar registros asignados por cambio de asignacion
        public void metEliminarRegistrosBienes(string varConexion, string Lis)
        {
            auxClsAsigBienes.metConfigurarEliminarReg(varConexion);
            auxClsAsigBienes.metActivarEliminarReg(Lis);
        }
        //Presentar los registros activos
        public void metInicioRegistrosActivos(string Con, LogisticaDeAcceso.ColeccionDeDatos Col)
        {
            auxClsAsigBienes.metConfigurarRegistrosActivos(Con);
            auxClsAsigBienes.metActivarRegistrosActivos(Col);
        }
        //Cambiar el estado de las asignaciones
        public void metCancelarBienes(string Con, string Cod, string Est, string Cun)
        {
            auxClsAsigBienes.metConfigurarCancelarProducto(Con);
            auxClsAsigBienes.metActivarCancelarProducto(Cod, Est, Cun);
        }
        //Presentar los biene asignados
        public void metMostrarVienesAsignados(string varConexion, string Cod, LogisticaDeAcceso.ColeccionDeDatos Col)
        {
            auxClsAsigBienes.metConfigurarVistaBienesAsignados(varConexion);
            auxClsAsigBienes.metActivarVistaBienesAsignados(Cod, Col);
        }
        //Presentar proveedores cancelados
        public void metMostrarProveedoresCancelarB(string varConexion, LogisticaDeAcceso.ColeccionDeDatos Col)
        {
            auxClsAsigBienes.metConfigurarVistaProveedores(varConexion);
            auxClsAsigBienes.metActivarVistaProveedores(Col);
        }
        //Registrar las asignaciones
        public void metRegistrarAsignacionesPen(string Con, string Cod, string Come, string Cuenta)
        {
            auxClsAsigBienes.metConfigurarIngresoPendientes(Con);
            auxClsAsigBienes.metActivarIngresoPendientes(Cod, Come, Cuenta);
        }
        //Presentar las asignaciones pendientes
        public void metInicioAsignacionesPendientes(string Con, LogisticaDeAcceso.ColeccionDeDatos Col)
        {
            auxClsAsigBienes.metConfigurarAsignacionesPendientes(Con);
            auxClsAsigBienes.metActivarAsignacionesPendientes(Col);
        }


       /// /////////////////////////////////////////////////////////////////////////////////////////////////////
       /// ///////////////////////////ASIGANCION DE SERVICIOS//////////////////////////////////////////////////

        //Presentar estados
        public void metIngresoDeservicios(string varConexion, string Codigo)
        {
            auxClsActivServ.metConfigurarIngresoServicio(varConexion);
            auxClsActivServ.metActivarIngresoServicio(Codigo);
        }
        //Presentar registros pendientes
        public void metInicioRegistrosPendientes(string Con, LogisticaDeAcceso.ColeccionDeDatos Col)
        {
            auxClsActivServ.metConfigurarAsigServPendientes(Con);
            auxClsActivServ.metActivarAsigServPendientes(Col);
        }
        //Presentar registros inactivos
        public void metInicioActivServ(string Con,LogisticaDeAcceso.ColeccionDeDatos Col)
        {
            auxClsActivServ.metConfigurarRegistrosInactivos(Con);
            auxClsActivServ.metActivarRegistrosInactivos(Col);
        }
        //Cambiar el estado
        public void metActualizarEstado(string Con,string Pal)
        {
            auxClsActivServ.metConfigurarActualizarEstado(Con);
            auxClsActivServ.metActivarActualizarEstado(Pal, 1);
        }
        //Modificar los datos de los registros
        public void metActualizarPedidosAsignarS(string varConexion, LogisticaDeAcceso.ColeccionDeDatos Col)
        {
            auxClsActivServ.metConfigurarPedidosEnRegSer(varConexion);//Configurar lso pedidos registrados
            auxClsActivServ.metActivarPedidosEnRegSer(Col);//Activa los datos pa visualizarlos
        }
        //Presentar servicios registrados
        public void metActualizarServiciosAsignarS(string varConexion, string Num, LogisticaDeAcceso.ColeccionDeDatos Col)
        {
            auxClsActivServ.metConfigurarMostrarServicios(varConexion);//Configura la actualizacion
            auxClsActivServ.metActivarMostrarServicios(Col, Num);//Activa la vista
        }
        //Ingresar asignacion de servicios
        public void metIngresarAsignacionAsignarS(string varConexion, string CodR, string CodP, string Mod, string Obs, string fechaSol, string fechaAsig)
        {
            auxClsActivServ.metConfigurarIngresoAsigServicio(varConexion);//Configuracion del ingreso de datos en la tabla 
            auxClsActivServ.metActivarIngresoAsigServicio(CodR, CodP, Mod, Obs, fechaSol, "Pendiente", fechaAsig);
            //Activa el ingreso de los datos a la base por medio de la clase
        }
        //Cambiar el estado del registro asignado
        public void metCambiarEstadoRegistroServicio(string varConexion, string Cod, int num)
        {
            auxClsActivServ.metConfigurarActualizarEstado(varConexion);
            auxClsActivServ.metActivarActualizarEstado(Cod, num);
        }
        //Eliminacion de registro de servicios para cuando se cancela el vinulo con un proveedor
        public void metEliminarRegistroServicio(string varConexion, string Cod)
        {
            auxClsActivServ.metConfigurarEliminraRegSer(varConexion);
            auxClsActivServ.metActivarEliminarRegSer(Cod);
        }
        //Registros inactivos
        public void metInicioRegistrosServiciosActivos(string varConexion, LogisticaDeAcceso.ColeccionDeDatos Col)
        {
            auxClsActivServ.metConfigurarRegistrosActivos(varConexion);
            auxClsActivServ.metActivarRegistrosActivos(Col);
        }
        //Asignacion de servicios
        public void metActualizarAsignacionServicios(string varConexion, string Serv, string Serv2, string Cun)
        {
            auxClsActivServ.metConfigurarActualizarAsignacion(varConexion);
            auxClsActivServ.metActivarActualizarAsignacion(Serv, Serv2, Cun);
        }
        //Lista de servicios asignados
        public void metListaServiciosAsig(string varConexion, string Cod, LogisticaDeAcceso.ColeccionDeDatos Col)
        {
            auxClsActivServ.metConfigurarListaServiciosAsignados(varConexion);
            auxClsActivServ.metActivarListaServiciosAsignados(Cod, Col);
        }
        //Presentar servicios asignados
        public void metMostraServiciosAsignados(string varConexion, LogisticaDeAcceso.ColeccionDeDatos Col)
        {
            auxClsActivServ.metConfigurarMostrarServciosAsignados(varConexion);
            auxClsActivServ.metActivarMostrarServiciosAsignados(Col);
        }

     
        /// //////////////////////////////////////////////////////////////////////////////////////////////////
        /// /////////////////////////ADMININSTRA CION DE CUENTAS/////////////////////////////////////////////
   
        public void metMostrarEstados(string auxConeccion,LogisticaDeAcceso.ColeccionDeDatos Col)
        {
            //Este metodo actualiza el dataset que se llama colecciondedatos
            //se utiliza para mostrar datos
            auxCls.metMostrarDatos(auxConeccion);
            auxCls.metActivaMostrarD(Col);
        }
        //Cambiar la contraseña
        public void metCambiarContraseña(string auxConeccion,string Cuenta,string ClaveAc,string Confirmacion)
        {
            auxCls.metCambiarContraseña(auxConeccion);//Configuracion del procedimiento
            auxCls.metEjecutarCambiarContra( Cuenta, ClaveAc, Confirmacion);
        }
        //Presenta la clve buscada
        public String[] metBuscarClave(string auxConeccion,string Cuentas,string PalSecreta,string Clave,string Observaciones)
        { 
            auxCls.metBuscarClave(auxConeccion);//Configuracion del metodo
            return auxCls.metEjecutarBuscarClave(Cuentas, PalSecreta, Clave, Observaciones);
        }
        //Presentar estado de cuenta 
        public string metPresentaEstados(string Cone,string Cuentas)
        {
            //metodo que presenta el estado de la cuenta.
            auxCls.metCofigurarPresentarEsta(Cone);
            return auxCls.metActivarPresentarEstad(Cuentas);
        }
        //Cambiar el nombre de la cuenta
        public string metCambiarNombreCuenta(string Con,string Cuentas,string NomNuevo)
        {
        auxCls.metCambiarNombre(Con);//Configuracion
        return auxCls.metEjecutarCambioNombre(Cuentas, NomNuevo);
        }
        //Ingreso de datos en la nueva cuenta
       public void metIngresoDatosCuenta(string Con,string Cuenta,string Clave,string NombreUs,string Apellido,string Tipo,string PalSecre,string NomCuenta,byte[] Imagen)
        {
            //Este metodo es el que accede a la base de datos por medio de una llamado a la biblioteca de clases
            auxCls.metConfiguracionInsertarPro(Con);
            auxCls.metLlamadoProc(Cuenta, Clave, NombreUs, Apellido, Tipo, PalSecre, DateTime.Now.ToString(), "Activo", "Cuenta creada por " + NomCuenta + "." + "\nLa cuenta esta sin ninguna observacion", Imagen);
        }
        //Cambiar imagen registrada
       public void metCambiarImagen(string Con,string Cuenta,byte[] Imagen)
       {
           auxCls.metCambiarImagen(Con);
           auxCls.ejcCambiarImagen(Cuenta, Imagen);
       }
        //Presentar imagen
       public void metMostrarImagenes(string Com,LogisticaDeAcceso.ColeccionDeDatos Col)
       {
           //Ejecucuion de la vista declarada en el motor debase de datos
           auxCls.metMostrarImg(Com);//Configuracion
           auxCls.ejcMostrarImg(Col);//Ejecucion del metodo de configuracion
       }
        //Modificar estado de cuenta
       public void metActualizarEstados(string Con,string Cuenta,string NueEsta,string Obs,string NomCuenta)
       {
           auxCls.metActualizarEstado(Con);
           auxCls.metEjecutarActualizadorEs(Cuenta, NueEsta, Obs, NomCuenta);
       }
        //Presentar informacion de cuentas
       public void metMostarInformacion(string Con,LogisticaDeAcceso.ColeccionDeDatos Col,string Cuenta)
       {
           auxCls.metConfigurarMostrarCuentas(Con);
           auxCls.metActivarMostrarCuentas(Col, Cuenta);
       }
        //Presentar datos de las cuentas para administracion
       public void metMostrarDatos(string varConeccion,LogisticaDeAcceso.ColeccionDeDatos Col)
       {
           auxCls.metMostrarDatos(varConeccion);
           auxCls.metActivaMostrarD(Col);
       }
        //Presentar el estado
       public string metPresentarEstado(string Con,string Nombre)
       {
           auxCls.metConfigurarEstadoCuenta(Con);
           return auxCls.metActivarMostrarEstados(Nombre);
       }
        //Eliminacion de la cuenta
       public void metEliminarCuentas(string con, string Codigo)
       {
           auxCls.metConfEliminarCuentas(con);
           auxCls.metActivarEliminraCuenta(Codigo);
       }
    }
}
